import { http } from "@/utils/http";

/** 统一响应格式 - 支持两种后端格式 */
export interface ApiResponse<T = any> {
  /** 是否成功 (格式1) */
  success?: boolean;
  /** 状态码 (格式2) */
  code?: number;
  /** 响应消息 */
  message: string;
  /** 响应数据 */
  data?: T;
  /** 时间戳 */
  timestamp?: number;
}

// ==================== 数据类型定义 ====================

/** 用户信息 */
export interface UserInfo {
  /** 用户ID */
  userId: number;
  /** 用户昵称 */
  nickName: string;
  /** 头像URL */
  avatar: string;
  /** 性别 */
  sex: string;
}

/** 评论响应数据 */
export interface ArticleCommentResponse {
  /** 评论ID */
  id: number;
  /** 文章ID */
  articleId: number;
  /** 评论用户信息 (优先字段) */
  author?: UserInfo;
  /** 评论用户信息 (兼容字段) */
  user?: UserInfo;
  /** 父评论ID，顶级评论为null */
  parentId: number | null;
  /** 被回复的用户信息，顶级评论为null */
  replyToUser: UserInfo | null;
  /** 根评论ID */
  rootId: number | null;
  /** 评论层级，从1开始 */
  level: number;
  /** 评论内容 */
  content: string;
  /** 点赞数 */
  likeCount: number;
  /** 回复数 */
  replyCount: number;
  /** 当前用户是否已点赞 */
  isLiked: boolean;
  /** 是否包含敏感词 */
  isSensitive: boolean;
  /** 敏感度评分 */
  sensitiveScore: number;
  /** 创建时间 */
  createTime: string;
  /** 子评论列表 */
  children: ArticleCommentResponse[];
  /** 是否有更多子评论 */
  hasMoreChildren: boolean;
  /** 子评论总数 */
  childrenTotal: number;
  /** 是否正在点赞中（前端状态） */
  isLiking?: boolean;
}

/** 分页响应数据 */
export interface PageResponse<T> {
  /** 数据列表 */
  records: T[];
  /** 总记录数 */
  total: number;
  /** 当前页码 */
  current: number;
  /** 每页大小 */
  size: number;
  /** 总页数 */
  pages: number;
  /** 是否有上一页 */
  hasPrevious: boolean;
  /** 是否有下一页 */
  hasNext: boolean;
}

/** 评论树查询参数 */
export interface CommentTreeQuery {
  /** 文章ID */
  articleId: number;
  /** 当前页码，从1开始 */
  current?: number;
  /** 每页大小，建议10-50 */
  size?: number;
  /** 最大评论层级，固定为2（两层级模式） */
  maxLevel?: number;
  /** 每层子评论限制数量，建议3-20 */
  childrenLimit?: number;
  /** 根评论排序方式：1=最新优先，2=最热优先，3=时间正序 */
  sortType?: number;
  /** 回复排序方式：1=时间正序，2=时间倒序，3=点赞数倒序 */
  replySortType?: number;
  /** 扁平化回复模式（类似微博/知乎） */
  flatReplies?: boolean;
  /** 是否只加载根评论（懒加载回复） */
  rootOnly?: boolean;
}

/** 创建评论请求参数 */
export interface CreateCommentRequest {
  /** 文章ID */
  articleId: number;
  /** 评论内容，1-1000字符 */
  content: string;
  /** 父评论ID，顶级评论不填 */
  parentId?: number | null;
  /** 被回复用户ID，顶级评论不填 */
  replyToUserId?: number | null;
}

/** 点赞评论请求参数 */
export interface LikeCommentRequest {
  /** 评论ID */
  commentId: number;
  /** true=点赞，false=取消点赞 */
  liked: boolean;
}

/** 点赞评论响应数据 */
export interface LikeCommentResponse {
  /** 评论ID */
  commentId: number;
  /** 是否已点赞 */
  liked: boolean;
  /** 点赞数 */
  likeCount: number;
  /** 响应消息 */
  message: string;
}

/** 评论统计信息 */
export interface CommentStats {
  /** 评论ID */
  commentId: number;
  /** 点赞数 */
  likeCount: number;
  /** 回复数 */
  replyCount: number;
  /** 浏览数 */
  viewCount: number;
  /** 最后回复时间 */
  lastReplyTime: string;
}

// ==================== API接口函数 ====================

/** 获取文章评论树形结构 */
export const getCommentTreeApi = (params: CommentTreeQuery) => {
  return http.request<ApiResponse<PageResponse<ArticleCommentResponse>>>(
    "get",
    "/api/comments/tree",
    { params }
  );
};

/** 发表评论 */
export const createCommentApi = (data: CreateCommentRequest) => {
  return http.request<ApiResponse<ArticleCommentResponse>>(
    "post",
    "/api/comments/create",
    { data }
  );
};

/** 点赞/取消点赞评论 */
export const likeCommentApi = (requestData: LikeCommentRequest) => {
  console.log("📝 likeCommentApi调用参数:", requestData);

  return http.request<ApiResponse<LikeCommentResponse>>(
    "post",
    "/api/comments/like",
    { data: requestData }
  );
};

/** 删除评论 */
export const deleteCommentApi = (commentId: number) => {
  return http.request<ApiResponse>("delete", `/api/comments/${commentId}`);
};

/** 获取评论统计信息 */
export const getCommentStatsApi = (commentId: number) => {
  return http.request<ApiResponse<CommentStats>>(
    "get",
    `/api/comments/${commentId}/stats`
  );
};

/** 获取文章评论列表 */
export const getArticleCommentsApi = (
  articleId: number,
  params?: {
    current?: number;
    size?: number;
    topLevelOnly?: boolean;
    sortType?: string;
  }
) => {
  return http.request<ApiResponse<ArticleCommentResponse[]>>(
    "get",
    `/api/comments/article/${articleId}`,
    { params }
  );
};

// ==================== 工具类 ====================

/** 检查API响应是否成功 */
export function isApiResponseSuccess(response: any): boolean {
  return response && (response.success === true || response.code === 200);
}

/** 用户端评论工具类 */
export class UserCommentUtils {
  /** 验证评论内容 */
  static validateContent(content: string): {
    valid: boolean;
    message?: string;
  } {
    if (!content || content.trim().length === 0) {
      return { valid: false, message: "评论内容不能为空" };
    }

    if (content.length > 1000) {
      return { valid: false, message: "评论内容不能超过1000字符" };
    }

    if (content.length < 1) {
      return { valid: false, message: "评论内容至少需要1个字符" };
    }

    return { valid: true };
  }

  /** 格式化错误消息 */
  static formatErrorMessage(error: any): string {
    if (typeof error === "string") {
      return error;
    }
    if (error?.response?.data?.message) {
      return error.response.data.message;
    }
    if (error?.message) {
      return error.message;
    }
    return "操作失败，请稍后重试";
  }

  /** 格式化时间显示 */
  static formatTime(timeStr: string): string {
    const time = new Date(timeStr);
    const now = new Date();
    const diff = now.getTime() - time.getTime();

    const minute = 60 * 1000;
    const hour = 60 * minute;
    const day = 24 * hour;

    if (diff < minute) {
      return "刚刚";
    } else if (diff < hour) {
      return `${Math.floor(diff / minute)}分钟前`;
    } else if (diff < day) {
      return `${Math.floor(diff / hour)}小时前`;
    } else if (diff < 7 * day) {
      return `${Math.floor(diff / day)}天前`;
    } else {
      return time.toLocaleDateString();
    }
  }

  /** 格式化数字显示 */
  static formatNumber(num: number): string {
    if (num < 1000) {
      return num.toString();
    } else if (num < 10000) {
      return `${(num / 1000).toFixed(1)}k`;
    } else {
      return `${(num / 10000).toFixed(1)}w`;
    }
  }

  /** 获取根评论排序类型描述 */
  static getSortTypeDescription(sortType: number): string {
    const descriptions = {
      1: "最新优先",
      2: "最热优先",
      3: "时间正序"
    };
    return descriptions[sortType] || `排序类型${sortType}`;
  }

  /** 获取回复排序类型描述 */
  static getReplySortTypeDescription(replySortType: number): string {
    const descriptions = {
      1: "时间正序",
      2: "时间倒序",
      3: "点赞数倒序"
    };
    return descriptions[replySortType] || `回复排序${replySortType}`;
  }

  /** 构建评论层级路径 */
  static buildCommentPath(level: number): string {
    return Array(level).fill("└─").join("");
  }

  /** 检查是否可以回复 */
  static canReply(
    comment: ArticleCommentResponse,
    maxLevel: number = 2
  ): boolean {
    // 在二层级显示模式下，所有评论都可以回复
    // 回复会根据 flatReplies 设置决定显示层级
    return true;
  }

  /** 计算评论热度分数 */
  static calculateHotScore(comment: ArticleCommentResponse): number {
    const likeWeight = 1;
    const replyWeight = 2;
    const timeWeight = 0.1;

    const timeDiff = Date.now() - new Date(comment.createTime).getTime();
    const daysDiff = timeDiff / (1000 * 60 * 60 * 24);

    return (
      comment.likeCount * likeWeight +
      comment.replyCount * replyWeight -
      daysDiff * timeWeight
    );
  }
}
